home *** CD-ROM | disk | FTP | other *** search
/ Night Owl 6 / Night Owl's Shareware - PDSI-006 - Night Owl Corp (1990).iso / 019a / view002.zip / VIEW.C < prev    next >
C/C++ Source or Header  |  1991-09-14  |  25KB  |  1,051 lines
  1. /*
  2. View 0.02 - A simple,small,windowed, text file viewer.
  3.  
  4. Copyright (c) 1991 James P. Goodwin.
  5. All rights reserved.
  6.  
  7. Redistribution and use in source and binary forms are per-
  8. mitted provided that the above copyright notice is dupli-
  9. cated in all such forms and that any documentation,
  10. advertising materials, and other materials related to such
  11. distribution and use acknowledge that the software was
  12. developed by James P. Goodwin.
  13.  
  14. THE SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS
  15. OR IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE
  16. IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PAR-
  17. TICULAR PURPOSE.
  18. */
  19.  
  20.  
  21. #include <stdio.h>
  22. #include <fcntl.h>
  23. #include <sys\types.h>
  24. #include <sys\stat.h>
  25. #include <io.h>
  26. #include <share.h>
  27. #include <stdlib.h>
  28. #include <string.h>
  29. #include <dos.h>
  30. #include <share.h>
  31. #include <conio.h>
  32. #include <limits.h>
  33. #include <direct.h>
  34. #include "view.h"
  35.  
  36. /*
  37.   GLOBAL variable initialization 
  38. */
  39. VIEW *viewstack = NULL;                  /* pointer to the bottom view on screen */
  40.  
  41. UCHAR _far *screen;              /* pointer to display ram */
  42.  
  43. #if VIEW_HAS_MEMORY
  44.                                          /* huge 0 pointer to memory */
  45. UCHAR _huge *memory = (char _huge *)0;
  46. #endif
  47.                                          /* characters used in hex/dec conversion routines */
  48. UCHAR  hexdigits[] = {"0123456789ABCDEF"};
  49.  
  50. int view_offset   = 0;                   /* current offset into display memory */
  51. int view_attr     = 0;                   /* current display attribute */
  52. int view_is_mono  = FALSE;               /* flag indicates mono (TRUE) or color (FALSE) */
  53. int view_cols     = 80;
  54. int view_rows     = 25;
  55. UCHAR _far *bios_rows = (UCHAR _far *)0x00400084;
  56. UINT _far *bios_cols  = (UINT _far *)0x0040004A;
  57.  
  58. UCHAR *view_line   = NULL;                /* line input buffer */
  59.  
  60. #if VIEW_HAS_DIR
  61.  
  62. UCHAR *view_curdir = NULL;                /* current directory when view entered */
  63. UINT   view_curdrive = 0;
  64.  
  65. #endif
  66.  
  67. /*
  68.   Array of attributes for color and monochrome displays
  69. */
  70.  
  71. int view_attr_list[2][5] = {
  72.                              {     /* Color Attributes */
  73.                              0x1f, /* Active Window */
  74.                              0x30, /* Inactive Window */
  75.                              0x4f, /* Error Message */
  76.                              0x1b, /* Get a String  */
  77.                              0x31  /* Get a String Cursor */
  78.                              }, 
  79.                              {     /* Mono Attributes */
  80.                              0x0f, /* Active Window */
  81.                              0x70, /* Inactive Window */
  82.                              0x0f, /* Error Message */
  83.                              0x01, /* Get a String  */
  84.                              0x70  /* Get a String Cursor */
  85.                              }
  86.                            };
  87.  
  88. /*
  89.  
  90.    Function: main( int argc, UCHAR *argv[] )
  91.  
  92.    Description: 
  93.      This function will :
  94.  
  95.      1) close any "extra" file handles we inherited from
  96.      whoever ran us to give us more views
  97.  
  98.      2) save the current directory
  99.  
  100.      3) figure out whether we're in color or monochrome and set the
  101.      video buffer address in screen
  102.  
  103.      4) check the standard input to see if it's a file and
  104.      if so add it to the list of views and open a new standard
  105.      input.
  106.  
  107.      5) if we have no command line arguments prompt for file name
  108.  
  109.      6) process all command line arguments as if they were file names
  110.  
  111.      7) go into the view user interface and view files
  112.  
  113.      8) if we exit this way restore current directory
  114. */
  115.  
  116. main( int argc, UCHAR *argv[] )
  117. {
  118.   int i;
  119.   char fname[15];
  120.  
  121.   _harderr(view_errfunc);
  122.                                          /* Close "extra" file handles */
  123.   _dos_close(fileno(stderr));
  124.   _dos_close(fileno(stdaux));
  125.   _dos_close(fileno(stdprn));
  126.   _dos_close(fileno(stdout));
  127.                                          /* Assume :) that video mode 7 is monochrome */
  128.   if (view_getvidmode() == 7)
  129.     {
  130.     view_is_mono = TRUE;
  131.     screen = (UCHAR _far *)0xB0000000;
  132.     }
  133.   else
  134.     {
  135.     view_is_mono = FALSE;
  136.     screen = (UCHAR _far *)0xB8000000;
  137.     }
  138.  
  139.   view_rows = (*bios_rows)+1;
  140.   view_cols = (*bios_cols);
  141.                                          /* Save the current directory */
  142. #if VIEW_HAS_DIR
  143.   _dos_getdrive(&view_curdrive);
  144.   view_curdir = getcwd(NULL,80);
  145.   if (!view_curdir)
  146.     view_error(1,"VIEW0001");
  147. #endif
  148.                                          /* If stdin is a file then add it */
  149.   if (!isatty(fileno(stdin))) 
  150.     view_new(NULL,0,0,16,45);
  151.                                          /* If no args prompt for file */
  152.   if (argc <= 1 && !viewstack )
  153.     {
  154. #if VIEW_HAS_NEWFILE
  155.     view_newfile();
  156. #else
  157.     view_error(1,"[command |]VIEW [<filename] [filename .. filenameN]");
  158. #endif
  159.     }
  160.   else                                   /* process args as file names */
  161.     {
  162.     for (i = 1; i < argc; i ++)
  163.       view_new(argv[i],0,0,16,45);
  164.     }
  165.                                          /* put it on the screen and play */
  166.                                          /* with it */
  167.   view();
  168.  
  169. #if VIEW_HAS_DIR
  170.   if (view_curdir)                       /* return to saved dir and release memory */
  171.     {
  172.     _dos_setdrive(view_curdrive,&i);
  173.     chdir(view_curdir);
  174.     free(view_curdir);
  175.     }
  176. #endif
  177. }
  178. /*
  179.    Function: void view(void)
  180.  
  181.    Description:
  182.      This function puts up the user interface for view and accepts the
  183.      users input. It is basically a big switch on what key they hit. The
  184.      keys break down into extended and regular, extended keys are always
  185.      preceded by a null scan code.
  186.  
  187.      There are a set of offsets row_offset,col_offset etc... these are
  188.      set when certain keys are hit and are added to their corresponding
  189.      fields. The view_refresh routine enforces all dimensional constraints
  190.      so we don't worry about "overflow" or "underflow" in this routine.
  191.  
  192.      If page_offset is set to a non-zero value then the file is read 
  193.      either forwards or backwards abs(page_offset) times.
  194.  
  195.      The different refresh modes are used to speed up the screen update
  196.      when only the top window needs to be updated or only the top window's
  197.      contents.
  198. */
  199. void view(void)
  200. {
  201.   int c1;                                /* first character read */
  202.   int c2;                                /* second character read */
  203.   int row_offset;                        /* change row of window */
  204.   int col_offset;                        /* change col of window */
  205.   int height_offset;                     /* change height of window */
  206.   int width_offset;                      /* change width of window */
  207.   int line_offset;                       /* change coff of window */
  208.   int page_offset;                       /* change page of contents of window */
  209.   int refresh_mode;                      /* see refresh modes in view.h */
  210.   VIEW *top;                             /* temporary ptr to top window */
  211.  
  212.   if (!viewstack) return;                /* there aren't any views so return */
  213.  
  214.   if (!view_line)                        /* allocate the line buffer if NULL */
  215.     {
  216.     if (!(view_line = malloc(VIEW_MAX_LINE+1)))
  217.       view_error(1,"VIEW0002");
  218.     }
  219.  
  220.   view_tile();                           /* arrange the windows nicely */
  221.   top = viewstack;
  222.   do
  223.     {
  224.     view_scroll(top,SCROLL_RESET);
  225.     top = top->next;
  226.     }
  227.   while( top != viewstack );
  228.  
  229.   view_refresh(REFRESH_ALL);             /* put them on the screen */
  230.  
  231.  
  232.   for(;;)
  233.     {
  234.     refresh_mode = REFRESH_ALL;          /* reset change variables */
  235.     row_offset   = 0;
  236.     col_offset   = 0;
  237.     height_offset= 0;
  238.     width_offset = 0;
  239.     line_offset  = 0;
  240.     page_offset  = SCROLL_NONE;
  241.  
  242.     c1 = getch();                        /* get a keystroke from console */
  243.     
  244.     switch( c1 )                         /* select an action based on key */
  245.       {
  246.       case 0:                            /* an extended key follows */
  247.         c2 = getch();                    /* get extended keysroke */
  248.  
  249.         switch(c2)
  250.           {
  251.           case CURSOR_DOWN:
  252.             refresh_mode = REFRESH_CONTENTS;
  253.             page_offset = SCROLL_DOWN;
  254.           break;
  255.  
  256.           case CURSOR_LEFT:
  257.             refresh_mode = REFRESH_CONTENTS;
  258.             line_offset = -3;
  259.           break;
  260.  
  261.           case CURSOR_RIGHT:
  262.             refresh_mode = REFRESH_CONTENTS;
  263.             line_offset = 3;
  264.           break;
  265.  
  266.           case CURSOR_UP:
  267.             refresh_mode = REFRESH_CONTENTS;
  268.             page_offset = SCROLL_UP;
  269.           break;
  270.  
  271.           case CNTL_CURSOR_LEFT:
  272.             refresh_mode = REFRESH_TOP;
  273.             col_offset = -3;
  274.           break;
  275.  
  276.           case CNTL_CURSOR_RIGHT:
  277.             refresh_mode = REFRESH_TOP;
  278.             col_offset = 3;
  279.           break;
  280.  
  281.           case CNTL_PGUP:
  282.             refresh_mode = REFRESH_TOP;
  283.             row_offset = -1;
  284.           break;
  285.  
  286.           case CNTL_PGDN:
  287.             refresh_mode = REFRESH_TOP;
  288.             row_offset = 1;
  289.           break;
  290.  
  291.           case CNTL_HOME:
  292.             view_tile();
  293.             height_offset = view_rows;
  294.             width_offset = view_cols;
  295.           break;
  296.  
  297.           case CNTL_END:
  298.             view_tile();
  299.           break;
  300.  
  301.           case PGDN:
  302.             refresh_mode = REFRESH_CONTENTS;
  303.             page_offset = SCROLL_PAGE_DOWN;
  304.           break;
  305.  
  306.           case PGUP:
  307.             refresh_mode = REFRESH_CONTENTS;
  308.             page_offset = SCROLL_PAGE_UP;
  309.           break;
  310.  
  311.           case HOME:
  312.             refresh_mode = REFRESH_CONTENTS;
  313.             page_offset  = SCROLL_HOME;
  314.           break;
  315.  
  316.           case END:
  317.             refresh_mode = REFRESH_CONTENTS;
  318.             page_offset  = SCROLL_END;
  319.           break;
  320.  
  321.           case SHIFT_TAB:
  322.             view_refresh(REFRESH_PREV);
  323.             page_offset  = SCROLL_RESET;
  324.           break;
  325.  
  326.           default:
  327.           continue;
  328.           }
  329.       break;
  330.  
  331.       case 'e':
  332.       case 'E':
  333.          view_refresh(REFRESH_OFF);
  334.  
  335.          if (view_rows < 43)
  336.            {
  337.            _asm
  338.               {
  339.               push es
  340.               mov  ax,40H
  341.               mov  es,ax
  342.               push es:[87H]
  343.               or   byte ptr es:[87H],1
  344.  
  345.               mov  ax,1112H
  346.               xor  bx,bx
  347.               int  10h
  348.  
  349.               pop  es:[87H]
  350.               pop  es
  351.  
  352.               mov  ax,1200H
  353.               mov  bx,0020H
  354.               int  10h
  355.               }
  356.             }
  357.           else
  358.             {
  359.             _asm
  360.                {
  361.                push es
  362.                mov  ax,40H
  363.                mov  es,ax
  364.                push es:[87H]
  365.                or   byte ptr es:[87H],1
  366.  
  367.                mov ax,1111H
  368.                xor bx,bx
  369.                int 10h
  370.  
  371.                pop  es:[87H]
  372.                pop  es
  373.                }
  374.             }
  375.  
  376.          view_rows = (*bios_rows)+1;
  377.          view_cols = (*bios_cols);
  378.          view_tile();
  379.          refresh_mode = REFRESH_ALL;
  380.       break;
  381.  
  382.  
  383.       case 'w':
  384.         refresh_mode = REFRESH_TOP;
  385.         width_offset = -3;
  386.       break;
  387.  
  388.       case 'W':
  389.         refresh_mode = REFRESH_TOP;
  390.         width_offset = 3;
  391.       break;
  392.  
  393.       case 'h':
  394.         refresh_mode = REFRESH_TOP;
  395.         height_offset = -3;
  396.       break;
  397.  
  398.       case 'H':
  399.         refresh_mode = REFRESH_TOP;
  400.         height_offset = 3;
  401.       break;
  402.  
  403.       case 'C':
  404.       case 'c':
  405.         view_new(viewstack->prev->vf->fname,viewstack->prev->row,viewstack->prev->col,viewstack->prev->rows,viewstack->prev->cols);
  406.         view_tile();
  407.         page_offset  = SCROLL_RESET;
  408.       break;
  409.  
  410. #if VIEW_HAS_GOTO
  411.       case 'g':
  412.       case 'G':
  413.         refresh_mode = REFRESH_CONTENTS;
  414.         page_offset  = SCROLL_RESET;
  415.         view_goto_line();
  416.       break;
  417. #endif
  418.  
  419. #if VIEW_HAS_SEARCH
  420.       case 'S':
  421.       case 's':
  422.         refresh_mode = REFRESH_CONTENTS;
  423.         page_offset  = SCROLL_RESET;
  424.         view_search();
  425.       break;
  426. #endif
  427.  
  428.  
  429. #if VIEW_HAS_NEWFILE
  430.       case 'F':
  431.       case 'f':
  432.         if (!view_newfile()) continue;
  433.         view_tile();
  434.         page_offset = SCROLL_RESET;
  435.       break;
  436. #endif
  437.  
  438.       case 'D':
  439.       case 'd':
  440.         view_delete();
  441.         view_tile();
  442.       break;
  443.  
  444. #if VIEW_HAS_RAW
  445.       case 'X':
  446.       case 'x':
  447.         viewstack->prev->vf->lmode = VIEW_HEX_MODE;
  448.         page_offset = SCROLL_RESET;
  449.       break;
  450.  
  451.       case 'B':
  452.       case 'b':
  453.         viewstack->prev->vf->lmode = VIEW_BIN_MODE;
  454.         page_offset = SCROLL_RESET;
  455.       break;
  456. #endif
  457.  
  458.       case TAB:
  459.         view_refresh(REFRESH_NEXT);
  460.         page_offset  = SCROLL_RESET;
  461.       break;
  462.  
  463.       case ESC:
  464.         view_quit();
  465.       break;
  466.  
  467.       default:
  468.       continue;
  469.       }
  470.  
  471.     top       = viewstack->prev;
  472.     top->row  += row_offset;
  473.     top->col  += col_offset;
  474.     top->coff += line_offset;
  475.     top->rows += height_offset;
  476.     top->cols += width_offset;
  477.  
  478.     view_scroll(top,page_offset);
  479.     view_refresh(refresh_mode);
  480.     }
  481. } 
  482.  
  483. void view_scroll( VIEW *current, int mode )
  484. {
  485.    int      i;
  486.    VIEWFILE *vf;
  487.    ULONG    *pos;
  488.    UCHAR    **lines;
  489.  
  490.    if (kbhit())
  491.      if (!getch()) getch();
  492.  
  493.    vf    = current->vf;
  494.    pos   = current->pos;
  495.    lines = current->lines;
  496.  
  497.    switch( mode )
  498.      {
  499.      case SCROLL_NONE     :
  500.      return;
  501.  
  502.      case SCROLL_DOWN     :
  503.        if (lines[0])
  504.          {
  505.          view_seek(vf,pos[(VIEW_LINE_VIEW-1)],SEEK_SET);
  506.          view_getl_fwd(vf,view_line,VIEW_MAX_LINE);
  507.  
  508.          memmove(pos,pos+1,(VIEW_LINE_VIEW-1)*sizeof(ULONG));
  509.  
  510.          if (lines[0]) free(lines[0]);
  511.  
  512.          memmove(lines,lines+1,(VIEW_LINE_VIEW-1)*sizeof(UCHAR *));
  513.  
  514.          pos[(VIEW_LINE_VIEW-1)] = view_tell(vf);
  515.  
  516.          if (!view_getl_fwd(vf,view_line,VIEW_MAX_LINE))
  517.            lines[(VIEW_LINE_VIEW-1)] = view_strdup(view_line);
  518.          else
  519.            {
  520.            lines[(VIEW_LINE_VIEW-1)] = NULL;
  521.            pos[(VIEW_LINE_VIEW-1)]   = LONG_MAX;
  522.            }
  523.          }
  524.      break;
  525.  
  526.  
  527.      case SCROLL_UP       :
  528.        if (pos[0])
  529.          {
  530.          view_seek(vf,pos[0],SEEK_SET);
  531.  
  532.          memmove(pos+1,pos,(VIEW_LINE_VIEW-1)*sizeof(ULONG));
  533.  
  534.          if (lines[(VIEW_LINE_VIEW-1)]) free(lines[(VIEW_LINE_VIEW-1)]);
  535.                     
  536.          memmove(lines+1,lines,(VIEW_LINE_VIEW-1)*sizeof(UCHAR *));
  537.  
  538.          view_getl_bwd(vf,view_line,VIEW_MAX_LINE);
  539.  
  540.          pos[0] = view_tell(vf);
  541.  
  542.          view_getl_fwd(vf,view_line,VIEW_MAX_LINE);
  543.  
  544.          lines[0] = view_strdup(view_line);
  545.          }
  546.      break;
  547.  
  548.      case SCROLL_PAGE_UP  :
  549.        for (i = 0; i < (current->rows-2); i++)
  550.          view_scroll(current,SCROLL_UP);
  551.      break;
  552.  
  553.      case SCROLL_PAGE_DOWN:
  554.        for (i = 0; i < (current->rows-2); i++)
  555.          view_scroll(current,SCROLL_DOWN);
  556.      break;
  557.  
  558.      case SCROLL_HOME     :
  559.        view_seek(vf,0L,SEEK_SET);
  560.        view_scroll(current,SCROLL_RESET);
  561.      break;
  562.  
  563.      case SCROLL_END      :
  564.        view_seek(vf,0L,SEEK_END);
  565.        view_scroll(current,SCROLL_RESET);
  566.        view_scroll(current,SCROLL_PAGE_UP);
  567.      break;
  568.  
  569.      case SCROLL_CLEAR    :
  570.        for (i = 0; i < VIEW_LINE_VIEW; i ++)
  571.          {
  572.          pos[i] = LONG_MAX;
  573.          if (lines[i])
  574.            {
  575.            free(lines[i]);
  576.            lines[i] = NULL;
  577.            }
  578.          }
  579.  
  580.        return;
  581.      break;
  582.  
  583.      case SCROLL_RESET    :
  584.  
  585.        view_scroll(current,SCROLL_CLEAR);
  586.  
  587.        for (i = 0; i < VIEW_LINE_VIEW; i ++ )
  588.          {
  589.          pos[i] = view_tell(vf);
  590.          if (!view_getl_fwd(vf,view_line,VIEW_MAX_LINE))
  591.            lines[i] = view_strdup(view_line);
  592.          else
  593.            break;
  594.          }
  595.      break;
  596.      }
  597.  
  598.   view_seek(vf,pos[0],SEEK_SET);
  599. }
  600.  
  601.  
  602. void view_new( UCHAR *fname, int row,int col,int rows,int cols )
  603. {
  604.   VIEW *new;
  605.   int th;
  606.  
  607.   if (!strcmp(fname,"Standard Input")) return;
  608.  
  609.   new = (VIEW *)malloc(sizeof(VIEW));
  610.   if (!new) view_error(1,"VIEW0003");
  611.  
  612.   if (!(new->vf = view_open(fname)))
  613.     {
  614.     free(new);
  615.     return;
  616.     }
  617.  
  618.   new->row  = row;
  619.   new->col  = col;
  620.   new->rows = rows;
  621.   new->cols = cols;
  622.   memset(new->pos,'\0',VIEW_LINE_VIEW*sizeof(ULONG));
  623.   memset(new->lines,'\0',VIEW_LINE_VIEW*sizeof(UCHAR *));
  624.   new->coff = 0;
  625.   new->save = NULL;
  626.  
  627.  
  628.   if (viewstack == NULL)
  629.     {
  630.     new->next = new;
  631.     new->prev = new;
  632.     viewstack = new;
  633.     }
  634.   else
  635.     {
  636.     new->next = viewstack;
  637.     new->prev = viewstack->prev;
  638.     viewstack->prev->next = new;
  639.     viewstack->prev = new;
  640.     }
  641. }
  642.  
  643. void view_restore( VIEW *trav )
  644. {
  645.    view_putsave(trav->save);
  646.    trav->save = NULL;
  647. }
  648.  
  649. void view_save( VIEW *trav )
  650. {
  651.    trav->save = view_getsave(trav->row,trav->col,trav->rows,trav->cols);
  652. }
  653.  
  654. void view_refresh(int refresh_mode)
  655. {
  656.    VIEW *trav;
  657.    int  r;
  658.    int  blank;
  659.    UCHAR _far *oscreen;
  660.  
  661.    if (refresh_mode != REFRESH_CONTENTS && refresh_mode != REFRESH_TOP)
  662.      {
  663.      oscreen = screen;
  664.  
  665.      screen = malloc(view_rows*(view_cols*2));
  666.      if (!screen)
  667.        {
  668.        screen = oscreen;
  669.        }
  670.      else
  671.        {
  672.        memmove(screen,oscreen,view_rows*(view_cols*2));
  673.        }
  674.      }
  675.  
  676.    if (refresh_mode != REFRESH_CONTENTS)
  677.      {
  678.      trav = viewstack->prev;
  679.  
  680.      do
  681.        {
  682.        if (trav->save)
  683.          view_restore(trav);
  684.      
  685.        trav = trav->prev;
  686.  
  687.        if (refresh_mode == REFRESH_CONTENTS || refresh_mode == REFRESH_TOP) break;
  688.        }
  689.      while(trav != viewstack->prev);
  690.      }
  691.  
  692.    if (refresh_mode == REFRESH_NEXT)
  693.      {
  694.      viewstack = viewstack->next;
  695.      refresh_mode = REFRESH_ALL;
  696.      }
  697.  
  698.    if (refresh_mode == REFRESH_PREV)
  699.      {
  700.      viewstack = viewstack->prev;
  701.      refresh_mode = REFRESH_ALL;
  702.      }
  703.  
  704.    if (refresh_mode != REFRESH_OFF) 
  705.      {
  706.      if (refresh_mode != REFRESH_ALL)
  707.        trav = viewstack->prev;
  708.      else
  709.        trav = viewstack;
  710.  
  711.      do 
  712.        {
  713.        if (trav == viewstack->prev)
  714.          view_attr = ACTIVE_WINDOW;
  715.        else
  716.          view_attr = INACTIVE_WINDOW;
  717.  
  718.        trav->rows = max(trav->rows,3);
  719.        trav->rows = min(trav->rows,view_rows);
  720.        trav->cols = max(trav->cols,3);
  721.        trav->cols = min(trav->cols,view_cols);
  722.  
  723.        trav->col  = max(trav->col,0);
  724.        trav->col  = min(trav->col,view_cols-trav->cols);
  725.  
  726.        trav->row  = max(trav->row,0);
  727.        trav->row  = min(trav->row,view_rows-trav->rows);
  728.                                
  729.        trav->coff = max(trav->coff,0);
  730.  
  731.        if (refresh_mode != REFRESH_CONTENTS)
  732.          {
  733.          view_save(trav);
  734.          view_frame(trav->vf->fname,trav->row,trav->col,trav->rows,trav->cols);
  735.          }
  736.  
  737.        for (r = 1; r < trav->rows-1; r ++)
  738.          {
  739.          blank = TRUE;
  740.          view_goto(trav->row+r,trav->col+1);
  741.  
  742.          if (trav->lines[r-1] && (strlen(trav->lines[r-1]) > trav->coff))
  743.            {
  744.            view_puts(trav->lines[r-1]+trav->coff,trav->cols-2);
  745.            blank = FALSE;
  746.            }
  747.  
  748.          if (blank) view_fill(' ',trav->cols-2);
  749.          }
  750.  
  751.        trav = trav->next;
  752.  
  753.        if (refresh_mode != REFRESH_ALL) break;
  754.        } 
  755.      while(trav != viewstack);
  756.      }
  757.  
  758.    if (refresh_mode == REFRESH_ALL || refresh_mode == REFRESH_OFF)
  759.      {
  760.      if (screen != oscreen)
  761.        {
  762.        memmove(oscreen,screen,view_rows*(view_cols*2));
  763.        free(screen);
  764.        screen = oscreen;
  765.        }
  766.      }
  767. }
  768.  
  769. void view_quit( void )
  770. {
  771.   for(;;) view_delete();
  772. }
  773.  
  774. void view_tile( void )
  775. {
  776. #if VIEW_HAS_TILE
  777.  
  778.   VIEW *trav;
  779.   int windows;
  780.   int vsize,hsize;
  781.   int row,col;
  782.  
  783.   if (!viewstack) return;
  784.  
  785.   windows = 0;
  786.   trav    = viewstack;
  787.  
  788.   do
  789.     {
  790.     windows ++;
  791.     trav = trav->next;
  792.     }
  793.   while (trav != viewstack);
  794.  
  795.   hsize = view_cols;
  796.   vsize = view_rows;
  797.  
  798.   while ( (view_cols/hsize)*(view_rows/vsize) < windows )
  799.     vsize --;
  800.  
  801.   if (vsize < 3)
  802.     {
  803.     vsize = view_rows;
  804.     while ( (view_cols/hsize)*(view_rows/vsize) < windows )
  805.       hsize --;
  806.     }
  807.  
  808.   if (hsize < 10)
  809.     {
  810.     hsize = view_cols;
  811.     vsize = 24;
  812.  
  813.     while ( (view_cols/hsize)*(view_rows/vsize) < windows )
  814.       {
  815.       hsize -= 3;
  816.       vsize --;
  817.       }
  818.     }
  819.     
  820.   trav = viewstack;
  821.   row  = 0;
  822.   col  = 0;
  823.  
  824.   do
  825.     {
  826.     trav->row = row;
  827.     trav->col = col;
  828.     trav->rows = vsize;
  829.     trav->cols = hsize;
  830.  
  831.     col += hsize;
  832.     if (col+hsize > view_cols)
  833.       {
  834.       col = 0;
  835.       row += vsize;
  836.       }
  837.     trav = trav->next;
  838.     }
  839.   while(trav != viewstack);
  840.  
  841. #endif /* VIEW_HAS_TILE */
  842. }
  843.   
  844. void view_delete( void )
  845. {
  846.    VIEW *hold;
  847.    int lets_exit = FALSE;
  848.    
  849.  
  850.    if (viewstack->prev == viewstack)
  851.      lets_exit = TRUE;
  852.  
  853.    hold = viewstack->prev;
  854.    viewstack->prev->prev->next = viewstack;
  855.    viewstack->prev = viewstack->prev->prev;
  856.    view_restore(hold);
  857.    view_scroll(hold,SCROLL_CLEAR);
  858.    view_close(hold->vf);
  859.    free(hold);
  860.  
  861.    if (lets_exit) 
  862.      {
  863.      if (view_line) free(view_line);
  864.  
  865. #if VIEW_HAS_DIR
  866.      if (view_curdir)
  867.        {
  868.        _dos_setdrive(view_curdrive,&lets_exit);
  869.        chdir(view_curdir);
  870.        free(view_curdir);
  871.        }
  872. #endif
  873.      exit(0);
  874.      }
  875. }
  876.  
  877. #if VIEW_HAS_NEWFILE
  878. int view_newfile( void )
  879. {
  880.   int c1,c2;
  881.   char fname[80];
  882.  
  883.   fname[0] = '\0';
  884.  
  885.   do
  886.     {
  887.     c1 = view_prompt("New File","Filename:",fname,40);
  888.  
  889. #if VIEW_HAS_DIR
  890.     if (c1 && !strlen(fname))
  891.       c1 = view_dir(fname);
  892. #endif
  893.  
  894.     if (c1 && (c2 = (access(fname,0)
  895. #if VIEW_HAS_MEMORY
  896.     && stricmp(fname,VIEW_MEM_NAME)
  897. #endif
  898.     ))) 
  899.       {
  900.       strcpy(fname,"File Not Found");
  901.       }
  902.     }
  903.   while(c1 && c2);
  904.  
  905.   if (c1)
  906.     {
  907.     view_new(fname,0,0,16,45);
  908.     return(TRUE);
  909.     }
  910.   else
  911.     return(FALSE);
  912. }
  913. #endif /* VIEW_HAS_NEWFILE */
  914.  
  915. #if VIEW_HAS_SEARCH
  916. int view_search( void )
  917. {
  918.   int c1,c2;
  919.   char pat[80];
  920.   UCHAR *found;
  921.   ULONG pos;
  922.   int ret;
  923.   VIEWFILE *vf;
  924.  
  925.   vf = viewstack->prev->vf;
  926.  
  927.  
  928.   pat[0] = '\0';
  929.  
  930.   do
  931.     {
  932.     c1 = view_prompt("Search","Pattern:",pat,40);
  933.  
  934.     if (c1)
  935.       {
  936.       view_seek(vf,viewstack->prev->pos[0],SEEK_SET);
  937.  
  938.       ret   = 0;
  939.       found = NULL;
  940.  
  941.       while(!ret && !found)
  942.         {
  943.         pos = view_tell(vf);
  944.         ret = view_getl_fwd(vf,view_line,VIEW_MAX_LINE);
  945.         if (!ret) found = strstr(view_line,pat);
  946.         }
  947.  
  948.       if (found)
  949.         {
  950.         view_seek(vf,pos,SEEK_SET);
  951.         viewstack->prev->coff = found-view_line;
  952.         return(TRUE);
  953.         }
  954.       else
  955.         strcpy(pat,"Pattern Not Found");
  956.       }
  957.     }
  958.   while(c1);
  959.  
  960.   return(FALSE);
  961. }
  962. #endif
  963.  
  964.  
  965. #if VIEW_HAS_GOTO
  966. void view_goto_line( void )
  967. {
  968.   int c1;
  969.   char pat[80];
  970.   ULONG pos;
  971.   int ret;
  972.   VIEWFILE *vf;
  973.   UCHAR *goto_pmt[] = {"Offset In File:","Memory Address (SSSSOOOO):","Line Number:"};
  974.   int   goto_len[]  = { 10, 8, 8 };
  975.   int   goto_base[] = { 10,16,10 };
  976.   int   goto_type;
  977.  
  978.   pat[0] = '\0';
  979.   vf = viewstack->prev->vf;
  980.  
  981.  
  982. #if VIEW_HAS_RAW
  983.   if (vf->lmode 
  984.  
  985. #if VIEW_HAS_MEMORY
  986.   && vf->fh != VIEW_MEM_HDL
  987. #endif
  988.  
  989.   )
  990.     goto_type = 0;
  991.  
  992. #if VIEW_HAS_MEMORY
  993.   else if (vf->lmode  && vf->fh == VIEW_MEM_HDL )
  994.     goto_type = 1;
  995. #endif
  996.  
  997.   else
  998. #endif /* VIEW_HAS_RAW */
  999.     goto_type = 2;
  1000.  
  1001.   c1 = view_prompt("Goto",goto_pmt[goto_type],pat,goto_len[goto_type]);
  1002.  
  1003.   if (c1)  
  1004.     {  
  1005.     pos = view_atoul(pat,goto_base[goto_type]);  
  1006.  
  1007.  
  1008.     switch(goto_type)  
  1009.       {  
  1010. #if VIEW_HAS_RAW
  1011.       case 0:  
  1012.         view_seek(vf,pos,SEEK_SET);  
  1013.       break;  
  1014. #endif
  1015.  
  1016. #if VIEW_HAS_MEMORY
  1017.       case 1:  
  1018.         view_seek(vf,(ULONG)(((UCHAR _huge *)pos)-memory),SEEK_SET);  
  1019.       break;  
  1020. #endif
  1021.  
  1022.       case 2:  
  1023.         view_seek(vf,0L,SEEK_SET);  
  1024.  
  1025.         ret = 0;
  1026.         while (!ret && pos)  
  1027.           {  
  1028.           ret = view_getl_fwd(vf,view_line,VIEW_MAX_LINE);  
  1029.           pos --;  
  1030.           }  
  1031.       break;  
  1032.       }  
  1033.     }  
  1034. }
  1035. #endif /* VIEW_HAS_GOTO */
  1036.  
  1037. void _far view_errfunc( void )
  1038. { 
  1039.   _hardresume(_HARDERR_FAIL);
  1040. }
  1041.  
  1042. UCHAR *view_strdup( UCHAR *str )
  1043. {
  1044.    str = strdup(str);
  1045.  
  1046.    if (!str)
  1047.      view_error(1,"VIEW0010");
  1048.  
  1049.    return(str);
  1050. }
  1051.